/* PythonGrammar30TokenManager.cc */
#include "./PythonGrammar30TokenManager.h"
static const unsigned long long jjbitVec0[] = {
    0xfffffffffffffffeULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL
};
static const unsigned long long jjbitVec2[] = {
    0x0ULL, 0x0ULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL
};
static const int jjnextStates[] = {
    4, 6, 7, 2, 3, 43, 44, 24, 62, 63, 68, 69, 72, 73, 76, 77,
    20, 21, 22, 23, 24, 26, 29, 32, 33, 34, 35, 37, 24, 22, 23, 24,
    27, 28, 30, 31, 36, 23, 24, 78, 79, 24, 11, 12, 15, 18, 48, 49,
    50, 51, 52, 55, 56, 59, 33, 34, 41, 42, 45, 46, 66, 67, 70, 71,
    74, 75, 80, 81,
};
static const JAVACC_STRING_TYPE jjstrLiteralImages[] = {
    "", "", "", "", "", "", "", "", "", "", "", "", "",
    "", "\74\111\116\104\105\116\124\76", "", "", "\50", "\51", "\173", "\175",
    "\133", "\135", "\73", "\54", "\56", "\72", "\53", "\55", "\55\76", "\52", "\57",
    "\57\57", "\52\52", "\74\74", "\76\76", "\45", "\176", "\136", "\174", "\46", "\75",
    "\76", "\74", "\75\75", "\74\75", "\76\75", "\41\75", "\53\75", "\55\75", "\52\75",
    "\57\75", "\57\57\75", "\45\75", "\46\75", "\174\75", "\136\75", "\74\74\75",
    "\76\76\75", "\52\52\75", "\157\162", "\141\156\144", "\156\157\164", "\151\163",
    "\151\156", "\154\141\155\142\144\141", "\151\146", "\145\154\163\145",
    "\145\154\151\146", "\167\150\151\154\145", "\146\157\162", "\164\162\171",
    "\145\170\143\145\160\164", "\144\145\146", "\143\154\141\163\163", "\146\151\156\141\154\154\171",
    "\160\141\163\163", "\142\162\145\141\153", "\143\157\156\164\151\156\165\145",
    "\162\145\164\165\162\156", "\171\151\145\154\144", "\151\155\160\157\162\164", "\146\162\157\155",
    "\144\145\154", "\162\141\151\163\145", "\147\154\157\142\141\154",
    "\156\157\156\154\157\143\141\154", "\141\163\163\145\162\164", "\141\163", "\167\151\164\150",
    "\106\141\154\163\145", "\124\162\165\145", "\116\157\156\145", "\100", "", "", "", "", "",
    "", "", "", "", "", "", "", "", "", "", "", "", "", "",
    "", "", "", "", "", "", "", "", "", "", "", "", "", "",
    "", "", "", "", "", "", "", "", "", "", "", "",
};

/** Lexer state names. */
static const JAVACC_STRING_TYPE lexStateNames[] = {
    "DEFAULT",
    "FORCE_NEWLINE1",
    "FORCE_NEWLINE2",
    "INDENTING",
    "INDENTATION_UNCHANGED",
    "UNREACHABLE",
    "IN_STRING11",
    "IN_STRING21",
    "IN_STRING13",
    "IN_STRING23",
    "IN_BSTRING11",
    "IN_BSTRING21",
    "IN_BSTRING13",
    "IN_BSTRING23",
    "IN_STRING1NLC",
    "IN_STRING2NLC",
    "IN_BSTRING1NLC",
    "IN_BSTRING2NLC",
};

/** Lex State array. */
static const int jjnewLexState[] = {
    -1, -1, -1, -1, -1, -1, 4, 3, -1, -1, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, 10, 11, 12, 13, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 15, 15, 16,
    16, 17, 17, 6, 7, 10, 11, -1, -1, -1, -1, -1, -1, -1,
};
static const unsigned long long jjtoToken[] = {
    0xfffffffffffe60c1ULL, 0xff003f7fffffffULL, 0x0ULL,
};
static const unsigned long long jjtoSkip[] = {
    0x19f3eULL, 0x0ULL, 0x0ULL,
};
static const unsigned long long jjtoSpecial[] = {
    0x18000ULL, 0x0ULL, 0x0ULL,
};

void  PythonGrammar30TokenManager::setDebugStream(FILE *ds) {
    debugStream = ds;
}

int PythonGrammar30TokenManager::jjStopStringLiteralDfa_3(int pos, unsigned long long active0) {
    switch (pos)
    {
    default :
        return -1;
    }
}

int  PythonGrammar30TokenManager::jjStartNfa_3(int pos, unsigned long long active0) {
    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
}

int  PythonGrammar30TokenManager::jjStopAtPos(int pos, int kind) {
    jjmatchedKind = kind;
    jjmatchedPos = pos;
    return pos + 1;
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_3() {
    if (curChar == 9) {
        return jjStopAtPos(0, 8);
    } else if (curChar == 12) {
        return jjStopAtPos(0, 10);
    } else if (curChar == 32) {
        return jjStopAtPos(0, 9);
    } else {
        return jjMoveNfa_3(1, 0);
    }
}

int PythonGrammar30TokenManager::jjMoveNfa_3(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 8;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;)
    {
        if (++jjround == 0x7fffffff)
            ReInitRounds();
        if (curChar < 64)
        {
            unsigned long long l = 1ULL << curChar;
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 1:
                    if ((0x2400ULL & l) != 0L)
                    {
                        if (kind > 11)
                            kind = 11;
                    }
                    else if (curChar == 35)
                        jjCheckNAddStates(0, 2);
                    if (curChar == 13)
                        jjstateSet[jjnewStateCnt++] = 0;
                    break;
                case 0:
                    if (curChar == 10 && kind > 11)
                        kind = 11;
                    break;
                case 2:
                    if ((0x2400ULL & l) != 0L && kind > 11)
                        kind = 11;
                    break;
                case 3:
                    if (curChar == 35)
                        jjCheckNAddStates(0, 2);
                    break;
                case 4:
                    if ((0xffffffffffffdbffULL & l) != 0L)
                        jjCheckNAddStates(0, 2);
                    break;
                case 5:
                    if (curChar == 10 && kind > 16)
                        kind = 16;
                    break;
                case 6:
                    if (curChar == 13)
                        jjstateSet[jjnewStateCnt++] = 5;
                    break;
                case 7:
                    if ((0x2400ULL & l) != 0L && kind > 16)
                        kind = 16;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else if (curChar < 128)
        {
            unsigned long long l = 1ULL << (curChar & 077);
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 4:
                    jjAddStates(0, 2);
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else
        {
            int hiByte = (curChar >> 8);
            int i1 = hiByte >> 6;
            unsigned long long l1 = 1ULL << (hiByte & 077);
            uint i2 = (curChar & 0xff) >> 6;
            unsigned long long l2 = 1ULL << (curChar & 077);
            do
            {
                switch(jjstateSet[--i])
                {
                case 4:
                    if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                        jjAddStates(0, 2);
                    break;
                default :
                    if (i2 == l2) break;
                    else break;
                }
            } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
            jjmatchedKind = kind;
            jjmatchedPos = curPos;
            kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 8 - startsAt)))
            return curPos;
        if (input_stream->endOfInput()) {
            return curPos;
        }
        curChar = input_stream->readChar();
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_14() {
    return 1;
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_15() {
    return 1;
}

int PythonGrammar30TokenManager::jjStopStringLiteralDfa_9(int pos, unsigned long long active0, unsigned long long active1, unsigned long long active2) {
    switch (pos)
    {
    case 0:
        if ((active1 & 0x8000000000000ULL) != 0L)
        {
            jjmatchedKind = 137;
            return -1;
        }
        return -1;
    case 1:
        if ((active1 & 0x8000000000000ULL) != 0L)
        {
            if (jjmatchedPos == 0)
            {
                jjmatchedKind = 137;
                jjmatchedPos = 0;
            }
            return -1;
        }
        return -1;
    default :
        return -1;
    }
}

int  PythonGrammar30TokenManager::jjStartNfa_9(int pos, unsigned long long active0, unsigned long long active1, unsigned long long active2) {
    return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0, active1, active2), pos + 1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_9() {
    if (curChar == 10) {
        return jjStopAtPos(0, 135);
    } else if (curChar == 13) {
        jjmatchedKind = 136;
        return jjMoveStringLiteralDfa1_9(0x0ULL, 0x40ULL);
    } else if (curChar == 34) {
        return jjMoveStringLiteralDfa1_9(0x8000000000000ULL, 0x0ULL);
    } else {
        return jjMoveNfa_9(0, 0);
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa1_9(unsigned long long active1, unsigned long long active2) {
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_9(0, 0L, active1, active2);
        return 1;
    }
    curChar = input_stream->readChar();
    if (curChar == 10) {
        if ((active2 & 0x40ULL) != 0L)
            return jjStopAtPos(1, 134);
    } else if (curChar == 34) {
        return jjMoveStringLiteralDfa2_9(active1, 0x8000000000000ULL, active2, 0L);
    } else {
    }
    return jjStartNfa_9(0, 0L, active1, active2);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa2_9(unsigned long long old1, unsigned long long active1, unsigned long long old2, unsigned long long active2) {
    if (((active1 &= old1) | (active2 &= old2)) == 0L)
        return jjStartNfa_9(0, 0L, old1, old2);
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_9(1, 0L, active1, 0L);
        return 2;
    }
    curChar = input_stream->readChar();
    if (curChar == 34) {
        if ((active1 & 0x8000000000000ULL) != 0L)
            return jjStopAtPos(2, 115);
    } else {
    }
    return jjStartNfa_9(1, 0L, active1, 0L);
}

int PythonGrammar30TokenManager::jjMoveNfa_9(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 3;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;)
    {
        if (++jjround == 0x7fffffff)
            ReInitRounds();
        if (curChar < 64)
        {
            unsigned long long l = 1ULL << curChar;
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if ((0xffffffffffffdbffULL & l) != 0L && kind > 137)
                        kind = 137;
                    break;
                case 2:
                    if ((0xffffffffffffdbffULL & l) != 0L && kind > 138)
                        kind = 138;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else if (curChar < 128)
        {
            unsigned long long l = 1ULL << (curChar & 077);
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (kind > 137)
                        kind = 137;
                    if (curChar == 92)
                        jjstateSet[jjnewStateCnt++] = 2;
                    break;
                case 1:
                    if (curChar == 92)
                        jjstateSet[jjnewStateCnt++] = 2;
                    break;
                case 2:
                    if (kind > 138)
                        kind = 138;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else
        {
            int hiByte = (curChar >> 8);
            int i1 = hiByte >> 6;
            unsigned long long l1 = 1ULL << (hiByte & 077);
            uint i2 = (curChar & 0xff) >> 6;
            unsigned long long l2 = 1ULL << (curChar & 077);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 137)
                        kind = 137;
                    break;
                case 2:
                    if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 138)
                        kind = 138;
                    break;
                default :
                    if (i2 == l2) break;
                    else break;
                }
            } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
            jjmatchedKind = kind;
            jjmatchedPos = curPos;
            kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 3 - startsAt)))
            return curPos;
        if (input_stream->endOfInput()) {
            return curPos;
        }
        curChar = input_stream->readChar();
    }
}

int PythonGrammar30TokenManager::jjStopStringLiteralDfa_7(int pos, unsigned long long active0, unsigned long long active1) {
    switch (pos)
    {
    case 0:
        if ((active1 & 0x400000000000000ULL) != 0L)
        {
            jjmatchedKind = 133;
            return 2;
        }
        return -1;
    case 1:
        if ((active1 & 0x400000000000000ULL) != 0L)
        {
            jjmatchedKind = 123;
            jjmatchedPos = 1;
            return -1;
        }
        return -1;
    default :
        return -1;
    }
}

int  PythonGrammar30TokenManager::jjStartNfa_7(int pos, unsigned long long active0, unsigned long long active1) {
    return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0, active1), pos + 1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_7() {
    if (curChar == 34) {
        return jjStopAtPos(0, 113);
    } else if (curChar == 92) {
        return jjMoveStringLiteralDfa1_7(0x400000000000000ULL);
    } else {
        return jjMoveNfa_7(0, 0);
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa1_7(unsigned long long active1) {
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_7(0, 0L, active1);
        return 1;
    }
    curChar = input_stream->readChar();
    if (curChar == 13) {
        return jjMoveStringLiteralDfa2_7(active1, 0x400000000000000ULL);
    } else {
    }
    return jjStartNfa_7(0, 0L, active1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa2_7(unsigned long long old1, unsigned long long active1) {
    if (((active1 &= old1)) == 0L)
        return jjStartNfa_7(0, 0L, old1);
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_7(1, 0L, active1);
        return 2;
    }
    curChar = input_stream->readChar();
    if (curChar == 10) {
        if ((active1 & 0x400000000000000ULL) != 0L)
            return jjStopAtPos(2, 122);
    } else {
    }
    return jjStartNfa_7(1, 0L, active1);
}

int PythonGrammar30TokenManager::jjMoveNfa_7(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 4;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;)
    {
        if (++jjround == 0x7fffffff)
            ReInitRounds();
        if (curChar < 64)
        {
            unsigned long long l = 1ULL << curChar;
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if ((0xffffffffffffdbffULL & l) != 0L && kind > 133)
                        kind = 133;
                    break;
                case 2:
                    if ((0x2400ULL & l) != 0L)
                    {
                        if (kind > 123)
                            kind = 123;
                    }
                    else if (curChar == 34)
                    {
                        if (kind > 133)
                            kind = 133;
                    }
                    break;
                case 3:
                    if (curChar == 34 && kind > 133)
                        kind = 133;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else if (curChar < 128)
        {
            unsigned long long l = 1ULL << (curChar & 077);
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (kind > 133)
                        kind = 133;
                    if (curChar == 92)
                        jjAddStates(3, 4);
                    break;
                case 2:
                    if (curChar == 92 && kind > 133)
                        kind = 133;
                    break;
                case 1:
                    if (curChar == 92)
                        jjAddStates(3, 4);
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else
        {
            int hiByte = (curChar >> 8);
            int i1 = hiByte >> 6;
            unsigned long long l1 = 1ULL << (hiByte & 077);
            uint i2 = (curChar & 0xff) >> 6;
            unsigned long long l2 = 1ULL << (curChar & 077);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 133)
                        kind = 133;
                    break;
                default :
                    if (i2 == l2) break;
                    else break;
                }
            } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
            jjmatchedKind = kind;
            jjmatchedPos = curPos;
            kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 4 - startsAt)))
            return curPos;
        if (input_stream->endOfInput()) {
            return curPos;
        }
        curChar = input_stream->readChar();
    }
}

int PythonGrammar30TokenManager::jjStopStringLiteralDfa_12(int pos, unsigned long long active0, unsigned long long active1, unsigned long long active2) {
    switch (pos)
    {
    case 0:
        if ((active1 & 0x40000000000000ULL) != 0L)
        {
            jjmatchedKind = 137;
            return -1;
        }
        return -1;
    case 1:
        if ((active1 & 0x40000000000000ULL) != 0L)
        {
            if (jjmatchedPos == 0)
            {
                jjmatchedKind = 137;
                jjmatchedPos = 0;
            }
            return -1;
        }
        return -1;
    default :
        return -1;
    }
}

int  PythonGrammar30TokenManager::jjStartNfa_12(int pos, unsigned long long active0, unsigned long long active1, unsigned long long active2) {
    return jjMoveNfa_12(jjStopStringLiteralDfa_12(pos, active0, active1, active2), pos + 1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_12() {
    if (curChar == 10) {
        return jjStopAtPos(0, 135);
    } else if (curChar == 13) {
        jjmatchedKind = 136;
        return jjMoveStringLiteralDfa1_12(0x0L, 0x40ULL);
    } else if (curChar == 39) {
        return jjMoveStringLiteralDfa1_12(0x40000000000000ULL, 0x0ULL);
    } else {
        return jjMoveNfa_12(0, 0);
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa1_12(unsigned long long active1, unsigned long long active2) {
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_12(0, 0L, active1, active2);
        return 1;
    }
    curChar = input_stream->readChar();
    if (curChar == 10) {
        if ((active2 & 0x40ULL) != 0L)
            return jjStopAtPos(1, 134);
    } else if (curChar == 39) {
        return jjMoveStringLiteralDfa2_12(active1, 0x40000000000000ULL, active2, 0L);
    } else {
    }
    return jjStartNfa_12(0, 0L, active1, active2);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa2_12(unsigned long long old1, unsigned long long active1, unsigned long long old2, unsigned long long active2) {
    if (((active1 &= old1) | (active2 &= old2)) == 0L)
        return jjStartNfa_12(0, 0L, old1, old2);
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_12(1, 0L, active1, 0L);
        return 2;
    }
    curChar = input_stream->readChar();
    if (curChar == 39) {
        if ((active1 & 0x40000000000000ULL) != 0L)
            return jjStopAtPos(2, 118);
    } else {
    }
    return jjStartNfa_12(1, 0L, active1, 0L);
}

int PythonGrammar30TokenManager::jjMoveNfa_12(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 3;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;)
    {
        if (++jjround == 0x7fffffff)
            ReInitRounds();
        if (curChar < 64)
        {
            unsigned long long l = 1ULL << curChar;
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if ((0xffffffffffffdbffULL & l) != 0L && kind > 137)
                        kind = 137;
                    break;
                case 2:
                    if ((0xffffffffffffdbffULL & l) != 0L && kind > 138)
                        kind = 138;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else if (curChar < 128)
        {
            unsigned long long l = 1ULL << (curChar & 077);
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (kind > 137)
                        kind = 137;
                    if (curChar == 92)
                        jjstateSet[jjnewStateCnt++] = 2;
                    break;
                case 1:
                    if (curChar == 92)
                        jjstateSet[jjnewStateCnt++] = 2;
                    break;
                case 2:
                    if (kind > 138)
                        kind = 138;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else
        {
            int hiByte = (curChar >> 8);
            int i1 = hiByte >> 6;
            unsigned long long l1 = 1ULL << (hiByte & 077);
            uint i2 = (curChar & 0xff) >> 6;
            unsigned long long l2 = 1ULL << (curChar & 077);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 137)
                        kind = 137;
                    break;
                case 2:
                    if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 138)
                        kind = 138;
                    break;
                default :
                    if (i2 == l2) break;
                    else break;
                }
            } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
            jjmatchedKind = kind;
            jjmatchedPos = curPos;
            kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 3 - startsAt)))
            return curPos;
        if (input_stream->endOfInput()) {
            return curPos;
        }
        curChar = input_stream->readChar();
    }
}

int PythonGrammar30TokenManager::jjStopStringLiteralDfa_10(int pos, unsigned long long active0, unsigned long long active1) {
    switch (pos)
    {
    case 0:
        if ((active1 & 0x1000000000000000ULL) != 0L)
        {
            jjmatchedKind = 132;
            return 2;
        }
        return -1;
    case 1:
        if ((active1 & 0x1000000000000000ULL) != 0L)
        {
            jjmatchedKind = 125;
            jjmatchedPos = 1;
            return -1;
        }
        return -1;
    default :
        return -1;
    }
}

int  PythonGrammar30TokenManager::jjStartNfa_10(int pos, unsigned long long active0, unsigned long long active1) {
    return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0, active1), pos + 1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_10() {
    if (curChar == 39) {
        return jjStopAtPos(0, 116);
    } else if (curChar == 92) {
        return jjMoveStringLiteralDfa1_10(0x1000000000000000ULL);
    } else {
        return jjMoveNfa_10(0, 0);
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa1_10(unsigned long long active1) {
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_10(0, 0L, active1);
        return 1;
    }
    curChar = input_stream->readChar();
    if (curChar == 13) {
        return jjMoveStringLiteralDfa2_10(active1, 0x1000000000000000ULL);
    } else {
    }
    return jjStartNfa_10(0, 0L, active1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa2_10(unsigned long long old1, unsigned long long active1) {
    if (((active1 &= old1)) == 0L)
        return jjStartNfa_10(0, 0L, old1);
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_10(1, 0L, active1);
        return 2;
    }
    curChar = input_stream->readChar();
    if (curChar == 10) {
        if ((active1 & 0x1000000000000000ULL) != 0L)
            return jjStopAtPos(2, 124);
    } else {
    }
    return jjStartNfa_10(1, 0L, active1);
}

int PythonGrammar30TokenManager::jjMoveNfa_10(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 4;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;)
    {
        if (++jjround == 0x7fffffff)
            ReInitRounds();
        if (curChar < 64)
        {
            unsigned long long l = 1ULL << curChar;
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if ((0xffffffffffffdbffULL & l) != 0L && kind > 132)
                        kind = 132;
                    break;
                case 2:
                    if ((0x2400ULL & l) != 0L)
                    {
                        if (kind > 125)
                            kind = 125;
                    }
                    else if (curChar == 39)
                    {
                        if (kind > 132)
                            kind = 132;
                    }
                    break;
                case 3:
                    if (curChar == 39 && kind > 132)
                        kind = 132;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else if (curChar < 128)
        {
            unsigned long long l = 1ULL << (curChar & 077);
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (kind > 132)
                        kind = 132;
                    if (curChar == 92)
                        jjAddStates(3, 4);
                    break;
                case 2:
                    if (curChar == 92 && kind > 132)
                        kind = 132;
                    break;
                case 1:
                    if (curChar == 92)
                        jjAddStates(3, 4);
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else
        {
            int hiByte = (curChar >> 8);
            int i1 = hiByte >> 6;
            unsigned long long l1 = 1ULL << (hiByte & 077);
            uint i2 = (curChar & 0xff) >> 6;
            unsigned long long l2 = 1ULL << (curChar & 077);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 132)
                        kind = 132;
                    break;
                default :
                    if (i2 == l2) break;
                    else break;
                }
            } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
            jjmatchedKind = kind;
            jjmatchedPos = curPos;
            kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 4 - startsAt)))
            return curPos;
        if (input_stream->endOfInput()) {
            return curPos;
        }
        curChar = input_stream->readChar();
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_16() {
    return 1;
}

int PythonGrammar30TokenManager::jjStopStringLiteralDfa_4(int pos, unsigned long long active0) {
    switch (pos)
    {
    default :
        return -1;
    }
}

int  PythonGrammar30TokenManager::jjStartNfa_4(int pos, unsigned long long active0) {
    return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_4() {
    if (curChar == 9) {
        return jjStopAtPos(0, 8);
    } else if (curChar == 12) {
        return jjStopAtPos(0, 10);
    } else if (curChar == 32) {
        return jjStopAtPos(0, 9);
    } else {
        return jjMoveNfa_4(1, 0);
    }
}

int PythonGrammar30TokenManager::jjMoveNfa_4(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 8;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;)
    {
        if (++jjround == 0x7fffffff)
            ReInitRounds();
        if (curChar < 64)
        {
            unsigned long long l = 1ULL << curChar;
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 1:
                    if ((0x2400ULL & l) != 0L)
                    {
                        if (kind > 11)
                            kind = 11;
                    }
                    else if (curChar == 35)
                        jjCheckNAddStates(0, 2);
                    if (curChar == 13)
                        jjstateSet[jjnewStateCnt++] = 0;
                    break;
                case 0:
                    if (curChar == 10 && kind > 11)
                        kind = 11;
                    break;
                case 2:
                    if ((0x2400ULL & l) != 0L && kind > 11)
                        kind = 11;
                    break;
                case 3:
                    if (curChar == 35)
                        jjCheckNAddStates(0, 2);
                    break;
                case 4:
                    if ((0xffffffffffffdbffULL & l) != 0L)
                        jjCheckNAddStates(0, 2);
                    break;
                case 5:
                    if (curChar == 10 && kind > 16)
                        kind = 16;
                    break;
                case 6:
                    if (curChar == 13)
                        jjstateSet[jjnewStateCnt++] = 5;
                    break;
                case 7:
                    if ((0x2400ULL & l) != 0L && kind > 16)
                        kind = 16;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else if (curChar < 128)
        {
            unsigned long long l = 1ULL << (curChar & 077);
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 4:
                    jjAddStates(0, 2);
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else
        {
            int hiByte = (curChar >> 8);
            int i1 = hiByte >> 6;
            unsigned long long l1 = 1ULL << (hiByte & 077);
            uint i2 = (curChar & 0xff) >> 6;
            unsigned long long l2 = 1ULL << (curChar & 077);
            do
            {
                switch(jjstateSet[--i])
                {
                case 4:
                    if (jjCanMove_0(hiByte, i1, i2, l1, l2))
                        jjAddStates(0, 2);
                    break;
                default :
                    if (i2 == l2) break;
                    else break;
                }
            } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
            jjmatchedKind = kind;
            jjmatchedPos = curPos;
            kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 8 - startsAt)))
            return curPos;
        if (input_stream->endOfInput()) {
            return curPos;
        }
        curChar = input_stream->readChar();
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_5() {
    if (curChar == 60) {
        return jjMoveStringLiteralDfa1_5(0x4000ULL);
    } else {
        return 1;
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa1_5(unsigned long long active0) {
    if (input_stream->endOfInput()) {
        return 1;
    }
    curChar = input_stream->readChar();
    if (curChar == 73) {
        return jjMoveStringLiteralDfa2_5(active0, 0x4000ULL);
    } else {
        return 2;
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa2_5(unsigned long long old0, unsigned long long active0) {
    if (((active0 &= old0)) == 0L)
        return 2;
    if (input_stream->endOfInput()) {
        return 2;
    }
    curChar = input_stream->readChar();
    if (curChar == 78) {
        return jjMoveStringLiteralDfa3_5(active0, 0x4000ULL);
    } else {
        return 3;
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa3_5(unsigned long long old0, unsigned long long active0) {
    if (((active0 &= old0)) == 0L)
        return 3;
    if (input_stream->endOfInput()) {
        return 3;
    }
    curChar = input_stream->readChar();
    if (curChar == 68) {
        return jjMoveStringLiteralDfa4_5(active0, 0x4000ULL);
    } else {
        return 4;
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa4_5(unsigned long long old0, unsigned long long active0) {
    if (((active0 &= old0)) == 0L)
        return 4;
    if (input_stream->endOfInput()) {
        return 4;
    }
    curChar = input_stream->readChar();
    if (curChar == 69) {
        return jjMoveStringLiteralDfa5_5(active0, 0x4000ULL);
    } else {
        return 5;
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa5_5(unsigned long long old0, unsigned long long active0) {
    if (((active0 &= old0)) == 0L)
        return 5;
    if (input_stream->endOfInput()) {
        return 5;
    }
    curChar = input_stream->readChar();
    if (curChar == 78) {
        return jjMoveStringLiteralDfa6_5(active0, 0x4000ULL);
    } else {
        return 6;
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa6_5(unsigned long long old0, unsigned long long active0) {
    if (((active0 &= old0)) == 0L)
        return 6;
    if (input_stream->endOfInput()) {
        return 6;
    }
    curChar = input_stream->readChar();
    if (curChar == 84) {
        return jjMoveStringLiteralDfa7_5(active0, 0x4000ULL);
    } else {
        return 7;
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa7_5(unsigned long long old0, unsigned long long active0) {
    if (((active0 &= old0)) == 0L)
        return 7;
    if (input_stream->endOfInput()) {
        return 7;
    }
    curChar = input_stream->readChar();
    if (curChar == 62) {
        if ((active0 & 0x4000ULL) != 0L)
            return jjStopAtPos(7, 14);
    } else {
        return 8;
    }
    return 8;
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_17() {
    return 1;
}

int PythonGrammar30TokenManager::jjStopStringLiteralDfa_0(int pos, unsigned long long active0, unsigned long long active1) {
    switch (pos)
    {
    case 0:
        if ((active1 & 0x108000ULL) != 0L)
        {
            jjmatchedKind = 94;
            return 82;
        }
        if ((active1 & 0x2000ULL) != 0L)
        {
            jjmatchedKind = 94;
            return 48;
        }
        if ((active0 & 0xf000000000000000ULL) != 0L || (active1 & 0x1fef5fffULL) != 0L)
        {
            jjmatchedKind = 94;
            return 10;
        }
        if ((active0 & 0x2000000ULL) != 0L)
            return 83;
        return -1;
    case 1:
        if ((active0 & 0x9000000000000000ULL) != 0L || (active1 & 0x1800005ULL) != 0L)
            return 10;
        if ((active0 & 0x6000000000000000ULL) != 0L || (active1 & 0x1e7fdffaULL) != 0L)
        {
            if (jjmatchedPos != 1)
            {
                jjmatchedKind = 94;
                jjmatchedPos = 1;
            }
            return 10;
        }
        if ((active1 & 0x2000ULL) != 0L)
        {
            if (jjmatchedPos != 1)
            {
                jjmatchedKind = 94;
                jjmatchedPos = 1;
            }
            return 84;
        }
        return -1;
    case 2:
        if ((active0 & 0x6000000000000000ULL) != 0L || (active1 & 0x802c0ULL) != 0L)
            return 10;
        if ((active1 & 0x1ef7fd3aULL) != 0L)
        {
            jjmatchedKind = 94;
            jjmatchedPos = 2;
            return 10;
        }
        return -1;
    case 3:
        if ((active1 & 0x1a041018ULL) != 0L)
            return 10;
        if ((active1 & 0x4f3ed22ULL) != 0L)
        {
            jjmatchedKind = 94;
            jjmatchedPos = 3;
            return 10;
        }
        return -1;
    case 4:
        if ((active1 & 0x4112420ULL) != 0L)
            return 10;
        if ((active1 & 0xe2c902ULL) != 0L)
        {
            jjmatchedKind = 94;
            jjmatchedPos = 4;
            return 10;
        }
        return -1;
    case 5:
        if ((active1 & 0xa28102ULL) != 0L)
            return 10;
        if ((active1 & 0x404800ULL) != 0L)
        {
            jjmatchedKind = 94;
            jjmatchedPos = 5;
            return 10;
        }
        return -1;
    case 6:
        if ((active1 & 0x800ULL) != 0L)
            return 10;
        if ((active1 & 0x404000ULL) != 0L)
        {
            jjmatchedKind = 94;
            jjmatchedPos = 6;
            return 10;
        }
        return -1;
    default :
        return -1;
    }
}

int  PythonGrammar30TokenManager::jjStartNfa_0(int pos, unsigned long long active0, unsigned long long active1) {
    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_0() {
    if (curChar == 33) {
        return jjMoveStringLiteralDfa1_0(0x800000000000ULL, 0x0ULL);
    } else if (curChar == 37) {
        jjmatchedKind = 36;
        return jjMoveStringLiteralDfa1_0(0x20000000000000ULL, 0x0ULL);
    } else if (curChar == 38) {
        jjmatchedKind = 40;
        return jjMoveStringLiteralDfa1_0(0x40000000000000ULL, 0x0ULL);
    } else if (curChar == 40) {
        return jjStopAtPos(0, 17);
    } else if (curChar == 41) {
        return jjStopAtPos(0, 18);
    } else if (curChar == 42) {
        jjmatchedKind = 30;
        return jjMoveStringLiteralDfa1_0(0x804000200000000ULL, 0x0ULL);
    } else if (curChar == 43) {
        jjmatchedKind = 27;
        return jjMoveStringLiteralDfa1_0(0x1000000000000ULL, 0x0ULL);
    } else if (curChar == 44) {
        return jjStopAtPos(0, 24);
    } else if (curChar == 45) {
        jjmatchedKind = 28;
        return jjMoveStringLiteralDfa1_0(0x2000020000000ULL, 0x0ULL);
    } else if (curChar == 46) {
        return jjStartNfaWithStates_0(0, 25, 83);
    } else if (curChar == 47) {
        jjmatchedKind = 31;
        return jjMoveStringLiteralDfa1_0(0x18000100000000ULL, 0x0ULL);
    } else if (curChar == 58) {
        return jjStopAtPos(0, 26);
    } else if (curChar == 59) {
        return jjStopAtPos(0, 23);
    } else if (curChar == 60) {
        jjmatchedKind = 43;
        return jjMoveStringLiteralDfa1_0(0x200200400000000ULL, 0x0ULL);
    } else if (curChar == 61) {
        jjmatchedKind = 41;
        return jjMoveStringLiteralDfa1_0(0x100000000000ULL, 0x0ULL);
    } else if (curChar == 62) {
        jjmatchedKind = 42;
        return jjMoveStringLiteralDfa1_0(0x400400800000000ULL, 0x0ULL);
    } else if (curChar == 64) {
        return jjStopAtPos(0, 93);
    } else if (curChar == 70) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x4000000ULL);
    } else if (curChar == 78) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x10000000ULL);
    } else if (curChar == 84) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x8000000ULL);
    } else if (curChar == 91) {
        return jjStopAtPos(0, 21);
    } else if (curChar == 93) {
        return jjStopAtPos(0, 22);
    } else if (curChar == 94) {
        jjmatchedKind = 38;
        return jjMoveStringLiteralDfa1_0(0x100000000000000ULL, 0x0ULL);
    } else if (curChar == 97) {
        return jjMoveStringLiteralDfa1_0(0x2000000000000000ULL, 0x1800000ULL);
    } else if (curChar == 98) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x2000ULL);
    } else if (curChar == 99) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x4400ULL);
    } else if (curChar == 100) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x80200ULL);
    } else if (curChar == 101) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x118ULL);
    } else if (curChar == 102) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x40840ULL);
    } else if (curChar == 103) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x200000ULL);
    } else if (curChar == 105) {
        return jjMoveStringLiteralDfa1_0(0x8000000000000000ULL, 0x20005ULL);
    } else if (curChar == 108) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x2ULL);
    } else if (curChar == 110) {
        return jjMoveStringLiteralDfa1_0(0x4000000000000000ULL, 0x400000ULL);
    } else if (curChar == 111) {
        return jjMoveStringLiteralDfa1_0(0x1000000000000000ULL, 0x0ULL);
    } else if (curChar == 112) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x1000ULL);
    } else if (curChar == 114) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x108000ULL);
    } else if (curChar == 116) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x80ULL);
    } else if (curChar == 119) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x2000020ULL);
    } else if (curChar == 121) {
        return jjMoveStringLiteralDfa1_0(0x0ULL, 0x10000ULL);
    } else if (curChar == 123) {
        return jjStopAtPos(0, 19);
    } else if (curChar == 124) {
        jjmatchedKind = 39;
        return jjMoveStringLiteralDfa1_0(0x80000000000000ULL, 0x0ULL);
    } else if (curChar == 125) {
        return jjStopAtPos(0, 20);
    } else if (curChar == 126) {
        return jjStopAtPos(0, 37);
    } else {
        return jjMoveNfa_0(0, 0);
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa1_0(unsigned long long active0, unsigned long long active1) {
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_0(0, active0, active1);
        return 1;
    }
    curChar = input_stream->readChar();
    if (curChar == 42) {
        if ((active0 & 0x200000000ULL) != 0L)
        {
            jjmatchedKind = 33;
            jjmatchedPos = 1;
        }
        return jjMoveStringLiteralDfa2_0(active0, 0x800000000000000ULL, active1, 0L);
    } else if (curChar == 47) {
        if ((active0 & 0x100000000ULL) != 0L)
        {
            jjmatchedKind = 32;
            jjmatchedPos = 1;
        }
        return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000ULL, active1, 0L);
    } else if (curChar == 60) {
        if ((active0 & 0x400000000ULL) != 0L)
        {
            jjmatchedKind = 34;
            jjmatchedPos = 1;
        }
        return jjMoveStringLiteralDfa2_0(active0, 0x200000000000000ULL, active1, 0L);
    } else if (curChar == 61) {
        if ((active0 & 0x100000000000ULL) != 0L)
            return jjStopAtPos(1, 44);
        else if ((active0 & 0x200000000000ULL) != 0L)
            return jjStopAtPos(1, 45);
        else if ((active0 & 0x400000000000ULL) != 0L)
            return jjStopAtPos(1, 46);
        else if ((active0 & 0x800000000000ULL) != 0L)
            return jjStopAtPos(1, 47);
        else if ((active0 & 0x1000000000000ULL) != 0L)
            return jjStopAtPos(1, 48);
        else if ((active0 & 0x2000000000000ULL) != 0L)
            return jjStopAtPos(1, 49);
        else if ((active0 & 0x4000000000000ULL) != 0L)
            return jjStopAtPos(1, 50);
        else if ((active0 & 0x8000000000000ULL) != 0L)
            return jjStopAtPos(1, 51);
        else if ((active0 & 0x20000000000000ULL) != 0L)
            return jjStopAtPos(1, 53);
        else if ((active0 & 0x40000000000000ULL) != 0L)
            return jjStopAtPos(1, 54);
        else if ((active0 & 0x80000000000000ULL) != 0L)
            return jjStopAtPos(1, 55);
        else if ((active0 & 0x100000000000000ULL) != 0L)
            return jjStopAtPos(1, 56);
    } else if (curChar == 62) {
        if ((active0 & 0x20000000ULL) != 0L)
            return jjStopAtPos(1, 29);
        else if ((active0 & 0x800000000ULL) != 0L)
        {
            jjmatchedKind = 35;
            jjmatchedPos = 1;
        }
        return jjMoveStringLiteralDfa2_0(active0, 0x400000000000000ULL, active1, 0L);
    } else if (curChar == 97) {
        return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x4101002ULL);
    } else if (curChar == 101) {
        return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x88200ULL);
    } else if (curChar == 102) {
        if ((active1 & 0x4ULL) != 0L)
            return jjStartNfaWithStates_0(1, 66, 10);
    } else if (curChar == 104) {
        return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20ULL);
    } else if (curChar == 105) {
        return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x2010800ULL);
    } else if (curChar == 108) {
        return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x200418ULL);
    } else if (curChar == 109) {
        return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20000ULL);
    } else if (curChar == 110) {
        if ((active1 & 0x1ULL) != 0L)
            return jjStartNfaWithStates_0(1, 64, 10);
        return jjMoveStringLiteralDfa2_0(active0, 0x2000000000000000ULL, active1, 0L);
    } else if (curChar == 111) {
        return jjMoveStringLiteralDfa2_0(active0, 0x4000000000000000ULL, active1, 0x10404040ULL);
    } else if (curChar == 114) {
        if ((active0 & 0x1000000000000000ULL) != 0L)
            return jjStartNfaWithStates_0(1, 60, 10);
        return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8042080ULL);
    } else if (curChar == 115) {
        if ((active0 & 0x8000000000000000ULL) != 0L)
            return jjStartNfaWithStates_0(1, 63, 10);
        else if ((active1 & 0x1000000ULL) != 0L)
        {
            jjmatchedKind = 88;
            jjmatchedPos = 1;
        }
        return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x800000ULL);
    } else if (curChar == 120) {
        return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x100ULL);
    } else {
    }
    return jjStartNfa_0(0, active0, active1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa2_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1) {
    if (((active0 &= old0) | (active1 &= old1)) == 0L)
        return jjStartNfa_0(0, old0, old1);
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_0(1, active0, active1);
        return 2;
    }
    curChar = input_stream->readChar();
    if (curChar == 61) {
        if ((active0 & 0x10000000000000ULL) != 0L)
            return jjStopAtPos(2, 52);
        else if ((active0 & 0x200000000000000ULL) != 0L)
            return jjStopAtPos(2, 57);
        else if ((active0 & 0x400000000000000ULL) != 0L)
            return jjStopAtPos(2, 58);
        else if ((active0 & 0x800000000000000ULL) != 0L)
            return jjStopAtPos(2, 59);
    } else if (curChar == 97) {
        return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x400ULL);
    } else if (curChar == 99) {
        return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x100ULL);
    } else if (curChar == 100) {
        if ((active0 & 0x2000000000000000ULL) != 0L)
            return jjStartNfaWithStates_0(2, 61, 10);
    } else if (curChar == 101) {
        return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x12000ULL);
    } else if (curChar == 102) {
        if ((active1 & 0x200ULL) != 0L)
            return jjStartNfaWithStates_0(2, 73, 10);
    } else if (curChar == 105) {
        return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x100030ULL);
    } else if (curChar == 108) {
        if ((active1 & 0x80000ULL) != 0L)
            return jjStartNfaWithStates_0(2, 83, 10);
        return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x4000000ULL);
    } else if (curChar == 109) {
        return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x2ULL);
    } else if (curChar == 110) {
        return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x10404800ULL);
    } else if (curChar == 111) {
        return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x240000ULL);
    } else if (curChar == 112) {
        return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x20000ULL);
    } else if (curChar == 114) {
        if ((active1 & 0x40ULL) != 0L)
            return jjStartNfaWithStates_0(2, 70, 10);
    } else if (curChar == 115) {
        return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x801008ULL);
    } else if (curChar == 116) {
        if ((active0 & 0x4000000000000000ULL) != 0L)
            return jjStartNfaWithStates_0(2, 62, 10);
        return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x2008000ULL);
    } else if (curChar == 117) {
        return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x8000000ULL);
    } else if (curChar == 121) {
        if ((active1 & 0x80ULL) != 0L)
            return jjStartNfaWithStates_0(2, 71, 10);
    } else {
    }
    return jjStartNfa_0(1, active0, active1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa3_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1) {
    if (((active0 &= old0) | (active1 &= old1)) == 0L)
        return jjStartNfa_0(1, old0, old1);
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_0(2, 0L, active1);
        return 3;
    }
    curChar = input_stream->readChar();
    if (curChar == 97) {
        return jjMoveStringLiteralDfa4_0(active1, 0x2800ULL);
    } else if (curChar == 98) {
        return jjMoveStringLiteralDfa4_0(active1, 0x200002ULL);
    } else if (curChar == 101) {
        if ((active1 & 0x8ULL) != 0L)
            return jjStartNfaWithStates_0(3, 67, 10);
        else if ((active1 & 0x8000000ULL) != 0L)
            return jjStartNfaWithStates_0(3, 91, 10);
        else if ((active1 & 0x10000000ULL) != 0L)
            return jjStartNfaWithStates_0(3, 92, 10);
        return jjMoveStringLiteralDfa4_0(active1, 0x800100ULL);
    } else if (curChar == 102) {
        if ((active1 & 0x10ULL) != 0L)
            return jjStartNfaWithStates_0(3, 68, 10);
    } else if (curChar == 104) {
        if ((active1 & 0x2000000ULL) != 0L)
            return jjStartNfaWithStates_0(3, 89, 10);
    } else if (curChar == 108) {
        return jjMoveStringLiteralDfa4_0(active1, 0x410020ULL);
    } else if (curChar == 109) {
        if ((active1 & 0x40000ULL) != 0L)
            return jjStartNfaWithStates_0(3, 82, 10);
    } else if (curChar == 111) {
        return jjMoveStringLiteralDfa4_0(active1, 0x20000ULL);
    } else if (curChar == 115) {
        if ((active1 & 0x1000ULL) != 0L)
            return jjStartNfaWithStates_0(3, 76, 10);
        return jjMoveStringLiteralDfa4_0(active1, 0x4100400ULL);
    } else if (curChar == 116) {
        return jjMoveStringLiteralDfa4_0(active1, 0x4000ULL);
    } else if (curChar == 117) {
        return jjMoveStringLiteralDfa4_0(active1, 0x8000ULL);
    } else {
    }
    return jjStartNfa_0(2, 0L, active1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa4_0(unsigned long long old1, unsigned long long active1) {
    if (((active1 &= old1)) == 0L)
        return jjStartNfa_0(2, 0L, old1);
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_0(3, 0L, active1);
        return 4;
    }
    curChar = input_stream->readChar();
    if (curChar == 97) {
        return jjMoveStringLiteralDfa5_0(active1, 0x200000ULL);
    } else if (curChar == 100) {
        if ((active1 & 0x10000ULL) != 0L)
            return jjStartNfaWithStates_0(4, 80, 10);
        return jjMoveStringLiteralDfa5_0(active1, 0x2ULL);
    } else if (curChar == 101) {
        if ((active1 & 0x20ULL) != 0L)
            return jjStartNfaWithStates_0(4, 69, 10);
        else if ((active1 & 0x100000ULL) != 0L)
            return jjStartNfaWithStates_0(4, 84, 10);
        else if ((active1 & 0x4000000ULL) != 0L)
            return jjStartNfaWithStates_0(4, 90, 10);
    } else if (curChar == 105) {
        return jjMoveStringLiteralDfa5_0(active1, 0x4000ULL);
    } else if (curChar == 107) {
        if ((active1 & 0x2000ULL) != 0L)
            return jjStartNfaWithStates_0(4, 77, 10);
    } else if (curChar == 108) {
        return jjMoveStringLiteralDfa5_0(active1, 0x800ULL);
    } else if (curChar == 111) {
        return jjMoveStringLiteralDfa5_0(active1, 0x400000ULL);
    } else if (curChar == 112) {
        return jjMoveStringLiteralDfa5_0(active1, 0x100ULL);
    } else if (curChar == 114) {
        return jjMoveStringLiteralDfa5_0(active1, 0x828000ULL);
    } else if (curChar == 115) {
        if ((active1 & 0x400ULL) != 0L)
            return jjStartNfaWithStates_0(4, 74, 10);
    } else {
    }
    return jjStartNfa_0(3, 0L, active1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa5_0(unsigned long long old1, unsigned long long active1) {
    if (((active1 &= old1)) == 0L)
        return jjStartNfa_0(3, 0L, old1);
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_0(4, 0L, active1);
        return 5;
    }
    curChar = input_stream->readChar();
    if (curChar == 97) {
        if ((active1 & 0x2ULL) != 0L)
            return jjStartNfaWithStates_0(5, 65, 10);
    } else if (curChar == 99) {
        return jjMoveStringLiteralDfa6_0(active1, 0x400000ULL);
    } else if (curChar == 108) {
        if ((active1 & 0x200000ULL) != 0L)
            return jjStartNfaWithStates_0(5, 85, 10);
        return jjMoveStringLiteralDfa6_0(active1, 0x800ULL);
    } else if (curChar == 110) {
        if ((active1 & 0x8000ULL) != 0L)
            return jjStartNfaWithStates_0(5, 79, 10);
        return jjMoveStringLiteralDfa6_0(active1, 0x4000ULL);
    } else if (curChar == 116) {
        if ((active1 & 0x100ULL) != 0L)
            return jjStartNfaWithStates_0(5, 72, 10);
        else if ((active1 & 0x20000ULL) != 0L)
            return jjStartNfaWithStates_0(5, 81, 10);
        else if ((active1 & 0x800000ULL) != 0L)
            return jjStartNfaWithStates_0(5, 87, 10);
    } else {
    }
    return jjStartNfa_0(4, 0L, active1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa6_0(unsigned long long old1, unsigned long long active1) {
    if (((active1 &= old1)) == 0L)
        return jjStartNfa_0(4, 0L, old1);
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_0(5, 0L, active1);
        return 6;
    }
    curChar = input_stream->readChar();
    if (curChar == 97) {
        return jjMoveStringLiteralDfa7_0(active1, 0x400000ULL);
    } else if (curChar == 117) {
        return jjMoveStringLiteralDfa7_0(active1, 0x4000ULL);
    } else if (curChar == 121) {
        if ((active1 & 0x800ULL) != 0L)
            return jjStartNfaWithStates_0(6, 75, 10);
    } else {
    }
    return jjStartNfa_0(5, 0L, active1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa7_0(unsigned long long old1, unsigned long long active1) {
    if (((active1 &= old1)) == 0L)
        return jjStartNfa_0(5, 0L, old1);
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_0(6, 0L, active1);
        return 7;
    }
    curChar = input_stream->readChar();
    if (curChar == 101) {
        if ((active1 & 0x4000ULL) != 0L)
            return jjStartNfaWithStates_0(7, 78, 10);
    } else if (curChar == 108) {
        if ((active1 & 0x400000ULL) != 0L)
            return jjStartNfaWithStates_0(7, 86, 10);
    } else {
    }
    return jjStartNfa_0(6, 0L, active1);
}

int PythonGrammar30TokenManager::jjStartNfaWithStates_0(int pos, int kind, int state) {
    jjmatchedKind = kind;
    jjmatchedPos = pos;
    if (input_stream->endOfInput()) {
        return pos + 1;
    }
    curChar = input_stream->readChar();
    return jjMoveNfa_0(state, pos + 1);
}

int PythonGrammar30TokenManager::jjMoveNfa_0(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 82;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;)
    {
        if (++jjround == 0x7fffffff)
            ReInitRounds();
        if (curChar < 64)
        {
            unsigned long long l = 1ULL << curChar;
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 84:
                    if ((0x3ff000000000000ULL & l) != 0L)
                    {
                        if (kind > 94)
                            kind = 94;
                        jjCheckNAdd(10);
                    }
                    else if (curChar == 34)
                        jjstateSet[jjnewStateCnt++] = 58;
                    else if (curChar == 39)
                        jjstateSet[jjnewStateCnt++] = 54;
                    if (curChar == 34)
                    {
                        if (kind > 105)
                            kind = 105;
                    }
                    else if (curChar == 39)
                    {
                        if (kind > 104)
                            kind = 104;
                    }
                    break;
                case 83:
                    if ((0x3ff000000000000ULL & l) != 0L)
                        jjCheckNAddStates(5, 7);
                    if ((0x3ff000000000000ULL & l) != 0L)
                    {
                        if (kind > 100)
                            kind = 100;
                        jjCheckNAddTwoStates(39, 40);
                    }
                    break;
                case 82:
                    if ((0x3ff000000000000ULL & l) != 0L)
                    {
                        if (kind > 94)
                            kind = 94;
                        jjCheckNAdd(10);
                    }
                    else if (curChar == 34)
                        jjstateSet[jjnewStateCnt++] = 17;
                    else if (curChar == 39)
                        jjstateSet[jjnewStateCnt++] = 14;
                    if (curChar == 34)
                    {
                        if (kind > 109)
                            kind = 109;
                    }
                    else if (curChar == 39)
                    {
                        if (kind > 108)
                            kind = 108;
                    }
                    break;
                case 0:
                    if ((0x3ff000000000000ULL & l) != 0L)
                        jjCheckNAddStates(8, 15);
                    else if ((0x2400ULL & l) != 0L)
                    {
                        if (kind > 5)
                            kind = 5;
                    }
                    else if (curChar == 46)
                        jjCheckNAddTwoStates(39, 43);
                    else if (curChar == 34)
                        jjstateSet[jjnewStateCnt++] = 17;
                    else if (curChar == 39)
                        jjstateSet[jjnewStateCnt++] = 14;
                    else if (curChar == 35)
                    {
                        if (kind > 15)
                            kind = 15;
                        jjCheckNAdd(8);
                    }
                    if ((0x3fe000000000000ULL & l) != 0L)
                    {
                        if (kind > 96)
                            kind = 96;
                        jjCheckNAddStates(16, 20);
                    }
                    else if (curChar == 48)
                    {
                        if (kind > 96)
                            kind = 96;
                        jjCheckNAddStates(21, 28);
                    }
                    else if (curChar == 34)
                    {
                        if (kind > 109)
                            kind = 109;
                    }
                    else if (curChar == 39)
                    {
                        if (kind > 108)
                            kind = 108;
                    }
                    else if (curChar == 13)
                        jjstateSet[jjnewStateCnt++] = 4;
                    break;
                case 48:
                    if ((0x3ff000000000000ULL & l) != 0L)
                    {
                        if (kind > 94)
                            kind = 94;
                        jjCheckNAdd(10);
                    }
                    else if (curChar == 34)
                        jjstateSet[jjnewStateCnt++] = 58;
                    else if (curChar == 39)
                        jjstateSet[jjnewStateCnt++] = 54;
                    if (curChar == 34)
                    {
                        if (kind > 105)
                            kind = 105;
                    }
                    else if (curChar == 39)
                    {
                        if (kind > 104)
                            kind = 104;
                    }
                    break;
                case 1:
                    if (curChar == 10 && kind > 4)
                        kind = 4;
                    break;
                case 2:
                    if (curChar == 13)
                        jjstateSet[jjnewStateCnt++] = 1;
                    break;
                case 3:
                    if ((0x2400ULL & l) != 0L && kind > 4)
                        kind = 4;
                    break;
                case 4:
                    if (curChar == 10 && kind > 5)
                        kind = 5;
                    break;
                case 5:
                    if (curChar == 13)
                        jjstateSet[jjnewStateCnt++] = 4;
                    break;
                case 6:
                    if ((0x2400ULL & l) != 0L && kind > 5)
                        kind = 5;
                    break;
                case 7:
                    if (curChar != 35)
                        break;
                    if (kind > 15)
                        kind = 15;
                    jjCheckNAdd(8);
                    break;
                case 8:
                    if ((0xffffffffffffdbffULL & l) == 0L)
                        break;
                    if (kind > 15)
                        kind = 15;
                    jjCheckNAdd(8);
                    break;
                case 10:
                    if ((0x3ff000000000000ULL & l) == 0L)
                        break;
                    if (kind > 94)
                        kind = 94;
                    jjCheckNAdd(10);
                    break;
                case 11:
                    if (curChar == 39 && kind > 108)
                        kind = 108;
                    break;
                case 12:
                    if (curChar == 34 && kind > 109)
                        kind = 109;
                    break;
                case 13:
                    if (curChar == 39 && kind > 110)
                        kind = 110;
                    break;
                case 14:
                    if (curChar == 39)
                        jjstateSet[jjnewStateCnt++] = 13;
                    break;
                case 15:
                    if (curChar == 39)
                        jjstateSet[jjnewStateCnt++] = 14;
                    break;
                case 16:
                    if (curChar == 34 && kind > 111)
                        kind = 111;
                    break;
                case 17:
                    if (curChar == 34)
                        jjstateSet[jjnewStateCnt++] = 16;
                    break;
                case 18:
                    if (curChar == 34)
                        jjstateSet[jjnewStateCnt++] = 17;
                    break;
                case 19:
                    if ((0x3fe000000000000ULL & l) == 0L)
                        break;
                    if (kind > 96)
                        kind = 96;
                    jjCheckNAddStates(16, 20);
                    break;
                case 20:
                    if ((0x3ff000000000000ULL & l) == 0L)
                        break;
                    if (kind > 96)
                        kind = 96;
                    jjCheckNAddTwoStates(20, 21);
                    break;
                case 22:
                    if ((0x3ff000000000000ULL & l) != 0L)
                        jjCheckNAddStates(29, 31);
                    break;
                case 25:
                    if (curChar != 48)
                        break;
                    if (kind > 96)
                        kind = 96;
                    jjCheckNAddStates(21, 28);
                    break;
                case 27:
                    if ((0x3ff000000000000ULL & l) == 0L)
                        break;
                    if (kind > 97)
                        kind = 97;
                    jjAddStates(32, 33);
                    break;
                case 30:
                    if ((0xff000000000000ULL & l) == 0L)
                        break;
                    if (kind > 98)
                        kind = 98;
                    jjAddStates(34, 35);
                    break;
                case 33:
                    if ((0x3000000000000ULL & l) == 0L)
                        break;
                    if (kind > 99)
                        kind = 99;
                    jjCheckNAddTwoStates(33, 34);
                    break;
                case 35:
                    if ((0x3fe000000000000ULL & l) != 0L)
                        jjCheckNAddStates(36, 38);
                    break;
                case 36:
                    if ((0x3ff000000000000ULL & l) != 0L)
                        jjCheckNAddStates(36, 38);
                    break;
                case 37:
                    if (curChar == 48)
                        jjCheckNAdd(24);
                    break;
                case 38:
                    if (curChar == 46)
                        jjCheckNAddTwoStates(39, 43);
                    break;
                case 39:
                    if ((0x3ff000000000000ULL & l) == 0L)
                        break;
                    if (kind > 100)
                        kind = 100;
                    jjCheckNAddTwoStates(39, 40);
                    break;
                case 41:
                    if ((0x280000000000ULL & l) != 0L)
                        jjCheckNAdd(42);
                    break;
                case 42:
                    if ((0x3ff000000000000ULL & l) == 0L)
                        break;
                    if (kind > 100)
                        kind = 100;
                    jjCheckNAdd(42);
                    break;
                case 43:
                    if ((0x3ff000000000000ULL & l) != 0L)
                        jjCheckNAddStates(5, 7);
                    break;
                case 45:
                    if ((0x280000000000ULL & l) != 0L)
                        jjCheckNAdd(46);
                    break;
                case 46:
                    if ((0x3ff000000000000ULL & l) != 0L)
                        jjCheckNAddTwoStates(46, 24);
                    break;
                case 49:
                    if (curChar == 39 && kind > 104)
                        kind = 104;
                    break;
                case 51:
                    if (curChar == 34 && kind > 105)
                        kind = 105;
                    break;
                case 53:
                    if (curChar == 39 && kind > 106)
                        kind = 106;
                    break;
                case 54:
                    if (curChar == 39)
                        jjstateSet[jjnewStateCnt++] = 53;
                    break;
                case 55:
                    if (curChar == 39)
                        jjstateSet[jjnewStateCnt++] = 54;
                    break;
                case 57:
                    if (curChar == 34 && kind > 107)
                        kind = 107;
                    break;
                case 58:
                    if (curChar == 34)
                        jjstateSet[jjnewStateCnt++] = 57;
                    break;
                case 59:
                    if (curChar == 34)
                        jjstateSet[jjnewStateCnt++] = 58;
                    break;
                case 61:
                    if ((0x3ff000000000000ULL & l) != 0L)
                        jjCheckNAddStates(8, 15);
                    break;
                case 62:
                    if ((0x3ff000000000000ULL & l) != 0L)
                        jjCheckNAddTwoStates(62, 63);
                    break;
                case 63:
                    if (curChar != 46)
                        break;
                    if (kind > 100)
                        kind = 100;
                    jjCheckNAddTwoStates(64, 65);
                    break;
                case 64:
                    if ((0x3ff000000000000ULL & l) == 0L)
                        break;
                    if (kind > 100)
                        kind = 100;
                    jjCheckNAddTwoStates(64, 65);
                    break;
                case 66:
                    if ((0x280000000000ULL & l) != 0L)
                        jjCheckNAdd(67);
                    break;
                case 67:
                    if ((0x3ff000000000000ULL & l) == 0L)
                        break;
                    if (kind > 100)
                        kind = 100;
                    jjCheckNAdd(67);
                    break;
                case 68:
                    if ((0x3ff000000000000ULL & l) != 0L)
                        jjCheckNAddTwoStates(68, 69);
                    break;
                case 70:
                    if ((0x280000000000ULL & l) != 0L)
                        jjCheckNAdd(71);
                    break;
                case 71:
                    if ((0x3ff000000000000ULL & l) == 0L)
                        break;
                    if (kind > 100)
                        kind = 100;
                    jjCheckNAdd(71);
                    break;
                case 72:
                    if ((0x3ff000000000000ULL & l) != 0L)
                        jjCheckNAddTwoStates(72, 73);
                    break;
                case 74:
                    if ((0x280000000000ULL & l) != 0L)
                        jjCheckNAdd(75);
                    break;
                case 75:
                    if ((0x3ff000000000000ULL & l) != 0L)
                        jjCheckNAddTwoStates(75, 24);
                    break;
                case 76:
                    if ((0x3ff000000000000ULL & l) != 0L)
                        jjCheckNAddTwoStates(76, 77);
                    break;
                case 77:
                    if (curChar == 46)
                        jjCheckNAddStates(39, 41);
                    break;
                case 78:
                    if ((0x3ff000000000000ULL & l) != 0L)
                        jjCheckNAddStates(39, 41);
                    break;
                case 80:
                    if ((0x280000000000ULL & l) != 0L)
                        jjCheckNAdd(81);
                    break;
                case 81:
                    if ((0x3ff000000000000ULL & l) != 0L)
                        jjCheckNAddTwoStates(81, 24);
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else if (curChar < 128)
        {
            unsigned long long l = 1ULL << (curChar & 077);
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 84:
                case 10:
                    if ((0x7fffffe87fffffeULL & l) == 0L)
                        break;
                    if (kind > 94)
                        kind = 94;
                    jjCheckNAdd(10);
                    break;
                case 82:
                    if ((0x7fffffe87fffffeULL & l) == 0L)
                        break;
                    if (kind > 94)
                        kind = 94;
                    jjCheckNAdd(10);
                    break;
                case 0:
                    if ((0x7fffffe87fffffeULL & l) != 0L)
                    {
                        if (kind > 94)
                            kind = 94;
                        jjCheckNAdd(10);
                    }
                    else if (curChar == 92)
                        jjAddStates(3, 4);
                    if ((0x4000000040000ULL & l) != 0L)
                        jjAddStates(42, 45);
                    else if ((0x400000004ULL & l) != 0L)
                        jjCheckNAddStates(46, 53);
                    break;
                case 48:
                    if ((0x7fffffe87fffffeULL & l) != 0L)
                    {
                        if (kind > 94)
                            kind = 94;
                        jjCheckNAdd(10);
                    }
                    if ((0x4000000040000ULL & l) != 0L)
                        jjCheckNAdd(59);
                    if ((0x4000000040000ULL & l) != 0L)
                        jjCheckNAdd(55);
                    if ((0x4000000040000ULL & l) != 0L)
                        jjCheckNAdd(51);
                    if ((0x4000000040000ULL & l) != 0L)
                        jjCheckNAdd(49);
                    break;
                case 8:
                    if (kind > 15)
                        kind = 15;
                    jjstateSet[jjnewStateCnt++] = 8;
                    break;
                case 9:
                    if ((0x7fffffe87fffffeULL & l) == 0L)
                        break;
                    if (kind > 94)
                        kind = 94;
                    jjCheckNAdd(10);
                    break;
                case 21:
                    if ((0x100000001000ULL & l) != 0L && kind > 96)
                        kind = 96;
                    break;
                case 23:
                    if ((0x100000001000ULL & l) != 0L)
                        jjstateSet[jjnewStateCnt++] = 24;
                    break;
                case 24:
                    if ((0x40000000400ULL & l) != 0L && kind > 101)
                        kind = 101;
                    break;
                case 26:
                    if ((0x100000001000000ULL & l) != 0L)
                        jjCheckNAdd(27);
                    break;
                case 27:
                    if ((0x7e0000007eULL & l) == 0L)
                        break;
                    if (kind > 97)
                        kind = 97;
                    jjCheckNAddTwoStates(27, 28);
                    break;
                case 28:
                    if ((0x100000001000ULL & l) != 0L && kind > 97)
                        kind = 97;
                    break;
                case 29:
                    if ((0x800000008000ULL & l) == 0L)
                        break;
                    if (kind > 98)
                        kind = 98;
                    jjAddStates(34, 35);
                    break;
                case 31:
                    if ((0x100000001000ULL & l) != 0L && kind > 98)
                        kind = 98;
                    break;
                case 32:
                    if ((0x400000004ULL & l) == 0L)
                        break;
                    if (kind > 99)
                        kind = 99;
                    jjAddStates(54, 55);
                    break;
                case 34:
                    if ((0x100000001000ULL & l) != 0L && kind > 99)
                        kind = 99;
                    break;
                case 40:
                    if ((0x2000000020ULL & l) != 0L)
                        jjAddStates(56, 57);
                    break;
                case 44:
                    if ((0x2000000020ULL & l) != 0L)
                        jjAddStates(58, 59);
                    break;
                case 47:
                    if ((0x400000004ULL & l) != 0L)
                        jjCheckNAddStates(46, 53);
                    break;
                case 50:
                    if ((0x4000000040000ULL & l) != 0L)
                        jjCheckNAdd(51);
                    break;
                case 52:
                    if ((0x4000000040000ULL & l) != 0L)
                        jjCheckNAdd(55);
                    break;
                case 56:
                    if ((0x4000000040000ULL & l) != 0L)
                        jjCheckNAdd(59);
                    break;
                case 60:
                    if ((0x4000000040000ULL & l) != 0L)
                        jjAddStates(42, 45);
                    break;
                case 65:
                    if ((0x2000000020ULL & l) != 0L)
                        jjAddStates(60, 61);
                    break;
                case 69:
                    if ((0x2000000020ULL & l) != 0L)
                        jjAddStates(62, 63);
                    break;
                case 73:
                    if ((0x2000000020ULL & l) != 0L)
                        jjAddStates(64, 65);
                    break;
                case 79:
                    if ((0x2000000020ULL & l) != 0L)
                        jjAddStates(66, 67);
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else
        {
            int hiByte = (curChar >> 8);
            int i1 = hiByte >> 6;
            unsigned long long l1 = 1ULL << (hiByte & 077);
            uint i2 = (curChar & 0xff) >> 6;
            unsigned long long l2 = 1ULL << (curChar & 077);
            do
            {
                switch(jjstateSet[--i])
                {
                case 84:
                case 10:
                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                        break;
                    if (kind > 94)
                        kind = 94;
                    jjCheckNAdd(10);
                    break;
                case 82:
                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                        break;
                    if (kind > 94)
                        kind = 94;
                    jjCheckNAdd(10);
                    break;
                case 0:
                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                        break;
                    if (kind > 94)
                        kind = 94;
                    jjCheckNAdd(10);
                    break;
                case 48:
                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                        break;
                    if (kind > 94)
                        kind = 94;
                    jjCheckNAdd(10);
                    break;
                case 8:
                    if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                        break;
                    if (kind > 15)
                        kind = 15;
                    jjstateSet[jjnewStateCnt++] = 8;
                    break;
                default :
                    if (i2 == l2) break;
                    else break;
                }
            } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
            jjmatchedKind = kind;
            jjmatchedPos = curPos;
            kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 82 - startsAt)))
            return curPos;
        if (input_stream->endOfInput()) {
            return curPos;
        }
        curChar = input_stream->readChar();
    }
}

int PythonGrammar30TokenManager::jjStopStringLiteralDfa_13(int pos, unsigned long long active0, unsigned long long active1, unsigned long long active2) {
    switch (pos)
    {
    case 0:
        if ((active1 & 0x80000000000000ULL) != 0L)
        {
            jjmatchedKind = 137;
            return -1;
        }
        return -1;
    case 1:
        if ((active1 & 0x80000000000000ULL) != 0L)
        {
            if (jjmatchedPos == 0)
            {
                jjmatchedKind = 137;
                jjmatchedPos = 0;
            }
            return -1;
        }
        return -1;
    default :
        return -1;
    }
}

int  PythonGrammar30TokenManager::jjStartNfa_13(int pos, unsigned long long active0, unsigned long long active1, unsigned long long active2) {
    return jjMoveNfa_13(jjStopStringLiteralDfa_13(pos, active0, active1, active2), pos + 1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_13() {
    if (curChar == 10) {
        return jjStopAtPos(0, 135);
    } else if (curChar == 13) {
        jjmatchedKind = 136;
        return jjMoveStringLiteralDfa1_13(0x0L, 0x40ULL);
    } else if (curChar == 34) {
        return jjMoveStringLiteralDfa1_13(0x80000000000000ULL, 0x0ULL);
    } else {
        return jjMoveNfa_13(0, 0);
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa1_13(unsigned long long active1, unsigned long long active2) {
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_13(0, 0L, active1, active2);
        return 1;
    }
    curChar = input_stream->readChar();
    if (curChar == 10) {
        if ((active2 & 0x40ULL) != 0L)
            return jjStopAtPos(1, 134);
    } else if (curChar == 34) {
        return jjMoveStringLiteralDfa2_13(active1, 0x80000000000000ULL, active2, 0L);
    } else {
    }
    return jjStartNfa_13(0, 0L, active1, active2);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa2_13(unsigned long long old1, unsigned long long active1, unsigned long long old2, unsigned long long active2) {
    if (((active1 &= old1) | (active2 &= old2)) == 0L)
        return jjStartNfa_13(0, 0L, old1, old2);
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_13(1, 0L, active1, 0L);
        return 2;
    }
    curChar = input_stream->readChar();
    if (curChar == 34) {
        if ((active1 & 0x80000000000000ULL) != 0L)
            return jjStopAtPos(2, 119);
    } else {
    }
    return jjStartNfa_13(1, 0L, active1, 0L);
}

int PythonGrammar30TokenManager::jjMoveNfa_13(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 3;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;)
    {
        if (++jjround == 0x7fffffff)
            ReInitRounds();
        if (curChar < 64)
        {
            unsigned long long l = 1ULL << curChar;
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if ((0xffffffffffffdbffULL & l) != 0L && kind > 137)
                        kind = 137;
                    break;
                case 2:
                    if ((0xffffffffffffdbffULL & l) != 0L && kind > 138)
                        kind = 138;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else if (curChar < 128)
        {
            unsigned long long l = 1ULL << (curChar & 077);
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (kind > 137)
                        kind = 137;
                    if (curChar == 92)
                        jjstateSet[jjnewStateCnt++] = 2;
                    break;
                case 1:
                    if (curChar == 92)
                        jjstateSet[jjnewStateCnt++] = 2;
                    break;
                case 2:
                    if (kind > 138)
                        kind = 138;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else
        {
            int hiByte = (curChar >> 8);
            int i1 = hiByte >> 6;
            unsigned long long l1 = 1ULL << (hiByte & 077);
            uint i2 = (curChar & 0xff) >> 6;
            unsigned long long l2 = 1ULL << (curChar & 077);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 137)
                        kind = 137;
                    break;
                case 2:
                    if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 138)
                        kind = 138;
                    break;
                default :
                    if (i2 == l2) break;
                    else break;
                }
            } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
            jjmatchedKind = kind;
            jjmatchedPos = curPos;
            kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 3 - startsAt)))
            return curPos;
        if (input_stream->endOfInput()) {
            return curPos;
        }
        curChar = input_stream->readChar();
    }
}

int PythonGrammar30TokenManager::jjStopStringLiteralDfa_11(int pos, unsigned long long active0, unsigned long long active1) {
    switch (pos)
    {
    case 0:
        if ((active1 & 0x4000000000000000ULL) != 0L)
        {
            jjmatchedKind = 133;
            return 2;
        }
        return -1;
    case 1:
        if ((active1 & 0x4000000000000000ULL) != 0L)
        {
            jjmatchedKind = 127;
            jjmatchedPos = 1;
            return -1;
        }
        return -1;
    default :
        return -1;
    }
}

int  PythonGrammar30TokenManager::jjStartNfa_11(int pos, unsigned long long active0, unsigned long long active1) {
    return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0, active1), pos + 1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_11() {
    if (curChar == 34) {
        return jjStopAtPos(0, 117);
    } else if (curChar == 92) {
        return jjMoveStringLiteralDfa1_11(0x4000000000000000ULL);
    } else {
        return jjMoveNfa_11(0, 0);
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa1_11(unsigned long long active1) {
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_11(0, 0L, active1);
        return 1;
    }
    curChar = input_stream->readChar();
    if (curChar == 13) {
        return jjMoveStringLiteralDfa2_11(active1, 0x4000000000000000ULL);
    } else {
    }
    return jjStartNfa_11(0, 0L, active1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa2_11(unsigned long long old1, unsigned long long active1) {
    if (((active1 &= old1)) == 0L)
        return jjStartNfa_11(0, 0L, old1);
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_11(1, 0L, active1);
        return 2;
    }
    curChar = input_stream->readChar();
    if (curChar == 10) {
        if ((active1 & 0x4000000000000000ULL) != 0L)
            return jjStopAtPos(2, 126);
    } else {
    }
    return jjStartNfa_11(1, 0L, active1);
}

int PythonGrammar30TokenManager::jjMoveNfa_11(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 4;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;)
    {
        if (++jjround == 0x7fffffff)
            ReInitRounds();
        if (curChar < 64)
        {
            unsigned long long l = 1ULL << curChar;
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if ((0xffffffffffffdbffULL & l) != 0L && kind > 133)
                        kind = 133;
                    break;
                case 2:
                    if ((0x2400ULL & l) != 0L)
                    {
                        if (kind > 127)
                            kind = 127;
                    }
                    else if (curChar == 34)
                    {
                        if (kind > 133)
                            kind = 133;
                    }
                    break;
                case 3:
                    if (curChar == 34 && kind > 133)
                        kind = 133;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else if (curChar < 128)
        {
            unsigned long long l = 1ULL << (curChar & 077);
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (kind > 133)
                        kind = 133;
                    if (curChar == 92)
                        jjAddStates(3, 4);
                    break;
                case 2:
                    if (curChar == 92 && kind > 133)
                        kind = 133;
                    break;
                case 1:
                    if (curChar == 92)
                        jjAddStates(3, 4);
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else
        {
            int hiByte = (curChar >> 8);
            int i1 = hiByte >> 6;
            unsigned long long l1 = 1ULL << (hiByte & 077);
            uint i2 = (curChar & 0xff) >> 6;
            unsigned long long l2 = 1ULL << (curChar & 077);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 133)
                        kind = 133;
                    break;
                default :
                    if (i2 == l2) break;
                    else break;
                }
            } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
            jjmatchedKind = kind;
            jjmatchedPos = curPos;
            kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 4 - startsAt)))
            return curPos;
        if (input_stream->endOfInput()) {
            return curPos;
        }
        curChar = input_stream->readChar();
    }
}

int PythonGrammar30TokenManager::jjStopStringLiteralDfa_8(int pos, unsigned long long active0, unsigned long long active1, unsigned long long active2) {
    switch (pos)
    {
    case 0:
        if ((active1 & 0x4000000000000ULL) != 0L)
        {
            jjmatchedKind = 137;
            return -1;
        }
        return -1;
    case 1:
        if ((active1 & 0x4000000000000ULL) != 0L)
        {
            if (jjmatchedPos == 0)
            {
                jjmatchedKind = 137;
                jjmatchedPos = 0;
            }
            return -1;
        }
        return -1;
    default :
        return -1;
    }
}

int  PythonGrammar30TokenManager::jjStartNfa_8(int pos, unsigned long long active0, unsigned long long active1, unsigned long long active2) {
    return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0, active1, active2), pos + 1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_8() {
    if (curChar == 10) {
        return jjStopAtPos(0, 135);
    } else if (curChar == 13) {
        jjmatchedKind = 136;
        return jjMoveStringLiteralDfa1_8(0x0ULL, 0x40ULL);
    } else if (curChar == 39) {
        return jjMoveStringLiteralDfa1_8(0x4000000000000ULL, 0x0ULL);
    } else {
        return jjMoveNfa_8(0, 0);
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa1_8(unsigned long long active1, unsigned long long active2) {
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_8(0, 0L, active1, active2);
        return 1;
    }
    curChar = input_stream->readChar();
    if (curChar == 10) {
        if ((active2 & 0x40ULL) != 0L)
            return jjStopAtPos(1, 134);
    } else if (curChar == 39) {
        return jjMoveStringLiteralDfa2_8(active1, 0x4000000000000ULL, active2, 0L);
    } else {
    }
    return jjStartNfa_8(0, 0L, active1, active2);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa2_8(unsigned long long old1, unsigned long long active1, unsigned long long old2, unsigned long long active2) {
    if (((active1 &= old1) | (active2 &= old2)) == 0L)
        return jjStartNfa_8(0, 0L, old1, old2);
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_8(1, 0L, active1, 0L);
        return 2;
    }
    curChar = input_stream->readChar();
    if (curChar == 39) {
        if ((active1 & 0x4000000000000ULL) != 0L)
            return jjStopAtPos(2, 114);
    } else {
    }
    return jjStartNfa_8(1, 0L, active1, 0L);
}

int PythonGrammar30TokenManager::jjMoveNfa_8(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 3;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;)
    {
        if (++jjround == 0x7fffffff)
            ReInitRounds();
        if (curChar < 64)
        {
            unsigned long long l = 1ULL << curChar;
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if ((0xffffffffffffdbffULL & l) != 0L && kind > 137)
                        kind = 137;
                    break;
                case 2:
                    if ((0xffffffffffffdbffULL & l) != 0L && kind > 138)
                        kind = 138;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else if (curChar < 128)
        {
            unsigned long long l = 1ULL << (curChar & 077);
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (kind > 137)
                        kind = 137;
                    if (curChar == 92)
                        jjstateSet[jjnewStateCnt++] = 2;
                    break;
                case 1:
                    if (curChar == 92)
                        jjstateSet[jjnewStateCnt++] = 2;
                    break;
                case 2:
                    if (kind > 138)
                        kind = 138;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else
        {
            int hiByte = (curChar >> 8);
            int i1 = hiByte >> 6;
            unsigned long long l1 = 1ULL << (hiByte & 077);
            uint i2 = (curChar & 0xff) >> 6;
            unsigned long long l2 = 1ULL << (curChar & 077);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 137)
                        kind = 137;
                    break;
                case 2:
                    if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 138)
                        kind = 138;
                    break;
                default :
                    if (i2 == l2) break;
                    else break;
                }
            } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
            jjmatchedKind = kind;
            jjmatchedPos = curPos;
            kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 3 - startsAt)))
            return curPos;
        if (input_stream->endOfInput()) {
            return curPos;
        }
        curChar = input_stream->readChar();
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_2() {
    return jjMoveNfa_2(0, 0);
}

int PythonGrammar30TokenManager::jjMoveNfa_2(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 1;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;)
    {
        if (++jjround == 0x7fffffff)
            ReInitRounds();
        if (curChar < 64)
        {
            unsigned long long l = 1ULL << curChar;
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if ((0x2400ULL & l) != 0L)
                        kind = 7;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else if (curChar < 128)
        {
            unsigned long long l = 1ULL << (curChar & 077);
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else
        {
            uint i2 = (curChar & 0xff) >> 6;
            unsigned long long l2 = 1ULL << (curChar & 077);
            do
            {
                switch(jjstateSet[--i])
                {
                default :
                    if (i2 == l2) break;
                    else break;
                }
            } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
            jjmatchedKind = kind;
            jjmatchedPos = curPos;
            kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 1 - startsAt)))
            return curPos;
        if (input_stream->endOfInput()) {
            return curPos;
        }
        curChar = input_stream->readChar();
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_1() {
    return jjMoveNfa_1(0, 0);
}

int PythonGrammar30TokenManager::jjMoveNfa_1(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 1;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;)
    {
        if (++jjround == 0x7fffffff)
            ReInitRounds();
        if (curChar < 64)
        {
            unsigned long long l = 1ULL << curChar;
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if ((0x2400ULL & l) != 0L)
                        kind = 6;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else if (curChar < 128)
        {
            unsigned long long l = 1ULL << (curChar & 077);
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else
        {
            uint i2 = (curChar & 0xff) >> 6;
            unsigned long long l2 = 1ULL << (curChar & 077);
            do
            {
                switch(jjstateSet[--i])
                {
                default :
                    if (i2 == l2) break;
                    else break;
                }
            } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
            jjmatchedKind = kind;
            jjmatchedPos = curPos;
            kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 1 - startsAt)))
            return curPos;
        if (input_stream->endOfInput()) {
            return curPos;
        }
        curChar = input_stream->readChar();
    }
}

int PythonGrammar30TokenManager::jjStopStringLiteralDfa_6(int pos, unsigned long long active0, unsigned long long active1) {
    switch (pos)
    {
    case 0:
        if ((active1 & 0x100000000000000ULL) != 0L)
        {
            jjmatchedKind = 132;
            return 2;
        }
        return -1;
    case 1:
        if ((active1 & 0x100000000000000ULL) != 0L)
        {
            jjmatchedKind = 121;
            jjmatchedPos = 1;
            return -1;
        }
        return -1;
    default :
        return -1;
    }
}

int  PythonGrammar30TokenManager::jjStartNfa_6(int pos, unsigned long long active0, unsigned long long active1) {
    return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0, active1), pos + 1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa0_6() {
    if (curChar == 39) {
        return jjStopAtPos(0, 112);
    } else if (curChar == 92) {
        return jjMoveStringLiteralDfa1_6(0x100000000000000ULL);
    } else {
        return jjMoveNfa_6(0, 0);
    }
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa1_6(unsigned long long active1) {
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_6(0, 0L, active1);
        return 1;
    }
    curChar = input_stream->readChar();
    if (curChar == 13) {
        return jjMoveStringLiteralDfa2_6(active1, 0x100000000000000ULL);
    } else {
    }
    return jjStartNfa_6(0, 0L, active1);
}

int  PythonGrammar30TokenManager::jjMoveStringLiteralDfa2_6(unsigned long long old1, unsigned long long active1) {
    if (((active1 &= old1)) == 0L)
        return jjStartNfa_6(0, 0L, old1);
    if (input_stream->endOfInput()) {
        jjStopStringLiteralDfa_6(1, 0L, active1);
        return 2;
    }
    curChar = input_stream->readChar();
    if (curChar == 10) {
        if ((active1 & 0x100000000000000ULL) != 0L)
            return jjStopAtPos(2, 120);
    } else {
    }
    return jjStartNfa_6(1, 0L, active1);
}

int PythonGrammar30TokenManager::jjMoveNfa_6(int startState, int curPos) {
    int startsAt = 0;
    jjnewStateCnt = 4;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
    for (;;)
    {
        if (++jjround == 0x7fffffff)
            ReInitRounds();
        if (curChar < 64)
        {
            unsigned long long l = 1ULL << curChar;
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if ((0xffffffffffffdbffULL & l) != 0L && kind > 132)
                        kind = 132;
                    break;
                case 2:
                    if ((0x2400ULL & l) != 0L)
                    {
                        if (kind > 121)
                            kind = 121;
                    }
                    else if (curChar == 39)
                    {
                        if (kind > 132)
                            kind = 132;
                    }
                    break;
                case 3:
                    if (curChar == 39 && kind > 132)
                        kind = 132;
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else if (curChar < 128)
        {
            unsigned long long l = 1ULL << (curChar & 077);
            if (l == 1);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (kind > 132)
                        kind = 132;
                    if (curChar == 92)
                        jjAddStates(3, 4);
                    break;
                case 2:
                    if (curChar == 92 && kind > 132)
                        kind = 132;
                    break;
                case 1:
                    if (curChar == 92)
                        jjAddStates(3, 4);
                    break;
                default :
                    break;
                }
            } while(i != startsAt);
        }
        else
        {
            int hiByte = (curChar >> 8);
            int i1 = hiByte >> 6;
            unsigned long long l1 = 1ULL << (hiByte & 077);
            uint i2 = (curChar & 0xff) >> 6;
            unsigned long long l2 = 1ULL << (curChar & 077);
            do
            {
                switch(jjstateSet[--i])
                {
                case 0:
                    if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 132)
                        kind = 132;
                    break;
                default :
                    if (i2 == l2) break;
                    else break;
                }
            } while(i != startsAt);
        }
        if (kind != 0x7fffffff)
        {
            jjmatchedKind = kind;
            jjmatchedPos = curPos;
            kind = 0x7fffffff;
        }
        ++curPos;
        if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 4 - startsAt)))
            return curPos;
        if (input_stream->endOfInput()) {
            return curPos;
        }
        curChar = input_stream->readChar();
    }
}

bool PythonGrammar30TokenManager::jjCanMove_0(int hiByte, int i1, int i2, unsigned long long l1, unsigned long long l2) {
    switch(hiByte)
    {
    case 0:
        return ((jjbitVec2[i2] & l2) != 0L);
    default :
        if ((jjbitVec0[i1] & l1) != 0L)
            return true;
        return false;
    }
}

/** Token literal values. */

TokenPtr PythonGrammar30TokenManager::jjFillToken() {
    JAVACC_STRING_TYPE curTokenImage;
    int beginLine;
    int endLine;
    int beginColumn;
    int endColumn;
    if (jjmatchedPos < 0)
    {
        curTokenImage = image.toString();
        beginLine = endLine = input_stream->getBeginLine();
        beginColumn = endColumn = input_stream->getBeginColumn();
    }
    else
    {
        JAVACC_STRING_TYPE im = jjstrLiteralImages[jjmatchedKind];
        curTokenImage = (im.length() == 0) ? input_stream->GetImage() : im;
        beginLine = input_stream->getBeginLine();
        beginColumn = input_stream->getBeginColumn();
        endLine = input_stream->getEndLine();
        endColumn = input_stream->getEndColumn();
    }
    TokenPtr t(Token::newToken(jjmatchedKind, curTokenImage));

    t->beginLine = beginLine;
    t->endLine = endLine;
    t->beginColumn = beginColumn;
    t->endColumn = endColumn;

    return t;
}
const int defaultLexState = 0;
/** Get the next Token. */

TokenPtr PythonGrammar30TokenManager::getNextToken() {
    TokenPtr specialToken(NULL);
    TokenPtr matchedToken;
    int curPos = 0;

    for (;;)
    {
EOFLoop:
        if (input_stream->endOfInput())
        {
            jjmatchedKind = 0;
            jjmatchedPos = -1;
            matchedToken = jjFillToken();
            matchedToken->specialToken = specialToken;
            CommonTokenAction(matchedToken);
            return matchedToken;
        }
        curChar = input_stream->BeginToken();
        image = jjimage;
        image.clear();
        jjimageLen = 0;

        for (;;)
        {
            switch(curLexState)
            {
            case 0:
            {   input_stream->backup(0);
                while (curChar <= 32 && (0x100001200ULL & (1ULL << curChar)) != 0L)
                {
                    if (input_stream->endOfInput()) {
                        goto EOFLoop;
                    }
                    curChar = input_stream->BeginToken();
                }
            }
            jjmatchedKind = 0x7fffffff;
            jjmatchedPos = 0;
            curPos = jjMoveStringLiteralDfa0_0();
            break;
            case 1:
                jjmatchedKind = 0x7fffffff;
                jjmatchedPos = 0;
                curPos = jjMoveStringLiteralDfa0_1();
                break;
            case 2:
                jjmatchedKind = 0x7fffffff;
                jjmatchedPos = 0;
                curPos = jjMoveStringLiteralDfa0_2();
                break;
            case 3:
                jjmatchedKind = 13;
                jjmatchedPos = -1;
                curPos = 0;
                curPos = jjMoveStringLiteralDfa0_3();
                break;
            case 4:
                jjmatchedKind = 12;
                jjmatchedPos = -1;
                curPos = 0;
                curPos = jjMoveStringLiteralDfa0_4();
                break;
            case 5:
                jjmatchedKind = 0x7fffffff;
                jjmatchedPos = 0;
                curPos = jjMoveStringLiteralDfa0_5();
                break;
            case 6:
                jjmatchedKind = 0x7fffffff;
                jjmatchedPos = 0;
                curPos = jjMoveStringLiteralDfa0_6();
                break;
            case 7:
                jjmatchedKind = 0x7fffffff;
                jjmatchedPos = 0;
                curPos = jjMoveStringLiteralDfa0_7();
                break;
            case 8:
                jjmatchedKind = 0x7fffffff;
                jjmatchedPos = 0;
                curPos = jjMoveStringLiteralDfa0_8();
                break;
            case 9:
                jjmatchedKind = 0x7fffffff;
                jjmatchedPos = 0;
                curPos = jjMoveStringLiteralDfa0_9();
                break;
            case 10:
                jjmatchedKind = 0x7fffffff;
                jjmatchedPos = 0;
                curPos = jjMoveStringLiteralDfa0_10();
                break;
            case 11:
                jjmatchedKind = 0x7fffffff;
                jjmatchedPos = 0;
                curPos = jjMoveStringLiteralDfa0_11();
                break;
            case 12:
                jjmatchedKind = 0x7fffffff;
                jjmatchedPos = 0;
                curPos = jjMoveStringLiteralDfa0_12();
                break;
            case 13:
                jjmatchedKind = 0x7fffffff;
                jjmatchedPos = 0;
                curPos = jjMoveStringLiteralDfa0_13();
                break;
            case 14:
                jjmatchedKind = 128;
                jjmatchedPos = -1;
                curPos = 0;
                curPos = jjMoveStringLiteralDfa0_14();
                break;
            case 15:
                jjmatchedKind = 129;
                jjmatchedPos = -1;
                curPos = 0;
                curPos = jjMoveStringLiteralDfa0_15();
                break;
            case 16:
                jjmatchedKind = 130;
                jjmatchedPos = -1;
                curPos = 0;
                curPos = jjMoveStringLiteralDfa0_16();
                break;
            case 17:
                jjmatchedKind = 131;
                jjmatchedPos = -1;
                curPos = 0;
                curPos = jjMoveStringLiteralDfa0_17();
                break;
            }
            if (jjmatchedKind != 0x7fffffff)
            {
                if (jjmatchedPos + 1 < curPos)
                    input_stream->backup(curPos - jjmatchedPos - 1);
                if ((jjtoToken[jjmatchedKind >> 6] & (1ULL << (jjmatchedKind & 077))) != 0L)
                {
                    matchedToken = jjFillToken();
                    matchedToken->specialToken = specialToken;
                    TokenLexicalActions(matchedToken);
                    if (jjnewLexState[jjmatchedKind] != -1)
                        curLexState = jjnewLexState[jjmatchedKind];
                    CommonTokenAction(matchedToken);
                    return matchedToken;
                }
                else if ((jjtoSkip[jjmatchedKind >> 6] & (1ULL << (jjmatchedKind & 077))) != 0L)
                {
                    if ((jjtoSpecial[jjmatchedKind >> 6] & (1ULL << (jjmatchedKind & 077))) != 0L)
                    {
                        matchedToken = jjFillToken();
                        if (specialToken == NULL)
                            specialToken = matchedToken;
                        else
                        {
                            matchedToken->specialToken = specialToken;
                            specialToken = (specialToken->next = matchedToken);
                        }
                        SkipLexicalActions(matchedToken);
                    }
                    else
                        SkipLexicalActions(TokenPtr(NULL));
                    if (jjnewLexState[jjmatchedKind] != -1)
                        curLexState = jjnewLexState[jjmatchedKind];
                    goto EOFLoop;
                }
                MoreLexicalActions();
                if (jjnewLexState[jjmatchedKind] != -1)
                    curLexState = jjnewLexState[jjmatchedKind];
                curPos = 0;
                jjmatchedKind = 0x7fffffff;
                if (!input_stream->endOfInput()) {
                    curChar = input_stream->readChar();
                    continue;
                }
            }
            int error_line = input_stream->getEndLine();
            int error_column = input_stream->getEndColumn();
            JAVACC_STRING_TYPE error_after;
            bool EOFSeen = false;
            if (input_stream->endOfInput()) {
                EOFSeen = true;
                error_after = curPos <= 1 ? "" : input_stream->GetImage();
                if (curChar == '\n' || curChar == '\r') {
                    error_line++;
                    error_column = 0;
                }
                else
                    error_column++;
            }
            if (!EOFSeen) {
                error_after = curPos <= 1 ? "" : input_stream->GetImage();
            }
            lexicalError(EOFSeen, curLexState, error_line, error_column, error_after, curChar);
            SwitchTo(0);
        }
    }
}


void  PythonGrammar30TokenManager::SkipLexicalActions(const TokenPtr& matchedToken) {
    switch(jjmatchedKind)
    {
    case 5 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        if (parens == 0) {
            indent = 0;
            input_stream->backup(1);
            if (level == 0)
                SwitchTo(FORCE_NEWLINE1);
            else
                SwitchTo(FORCE_NEWLINE2);
        }
        break;
    case 8 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        indenting((indent/8+1)*8);
        break;
    case 9 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        indenting(indent+1);
        break;
    case 10 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        indenting(0);
        break;
    case 11 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        indenting(0);
        break;
    case 16 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
//    System.out.println("SINGLE_LINE_COMMENT "+image);
//    matchedToken.image = image.toString();
        indenting(0);
        break;
    default :
        break;
    }
}

void  PythonGrammar30TokenManager::MoreLexicalActions() {
    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
    switch(jjmatchedKind)
    {
    case 120 :
        image.append(input_stream->GetSuffix(jjimageLen));
        jjimageLen = 0;
        image.setLength(image.length()-3);
        break;
    case 121 :
        image.append(input_stream->GetSuffix(jjimageLen));
        jjimageLen = 0;
        image.setLength(image.length()-2);
        break;
    case 122 :
        image.append(input_stream->GetSuffix(jjimageLen));
        jjimageLen = 0;
        image.setLength(image.length()-3);
        break;
    case 123 :
        image.append(input_stream->GetSuffix(jjimageLen));
        jjimageLen = 0;
        image.setLength(image.length()-2);
        break;
    case 124 :
        image.append(input_stream->GetSuffix(jjimageLen));
        jjimageLen = 0;
        image.setLength(image.length()-3);
        break;
    case 125 :
        image.append(input_stream->GetSuffix(jjimageLen));
        jjimageLen = 0;
        image.setLength(image.length()-2);
        break;
    case 126 :
        image.append(input_stream->GetSuffix(jjimageLen));
        jjimageLen = 0;
        image.setLength(image.length()-3);
        break;
    case 127 :
        image.append(input_stream->GetSuffix(jjimageLen));
        jjimageLen = 0;
        image.setLength(image.length()-2);
        break;
    case 134 :
        image.append(input_stream->GetSuffix(jjimageLen));
        jjimageLen = 0;
        {
            int l = image.length();
            image.setLength(l-1);
            image.setCharAt(l-2, '\n');
        }
        break;
    case 136 :
        image.append(input_stream->GetSuffix(jjimageLen));
        jjimageLen = 0;
        image.setCharAt(image.length()-1, '\n');
        break;
    default :
        break;
    }
}

void  PythonGrammar30TokenManager::TokenLexicalActions(const TokenPtr& matchedToken) {
    switch(jjmatchedKind)
    {
    case 7 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        matchedToken->kind = NEWLINE;

        break;
    case 13 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        if (indent > indentation[level]) {
            level++;
            indentation[level] = indent;
            matchedToken->kind=INDENT;
            matchedToken->image = "<INDENT>";
        }
        else if (level > 0) {
            TokenPtr t = matchedToken;
            level -= 1;
            while (level > 0 && indent < indentation[level]) {
                level--;
                t = addDedent(t);
            }
            if (indent != indentation[level]) {
                throw QString("inconsistent dedent %1 %2").arg(t->endLine).arg(t->endColumn);
            }
            t->next.clear();
        }

        break;
    case 17 :
        image.append(jjstrLiteralImages[17]);
        lengthOfMatch = jjstrLiteralImages[17].length();
        parens++;

        break;
    case 18 :
        image.append(jjstrLiteralImages[18]);
        lengthOfMatch = jjstrLiteralImages[18].length();
        parens--;

        break;
    case 19 :
        image.append(jjstrLiteralImages[19]);
        lengthOfMatch = jjstrLiteralImages[19].length();
        parens++;

        break;
    case 20 :
        image.append(jjstrLiteralImages[20]);
        lengthOfMatch = jjstrLiteralImages[20].length();
        parens--;

        break;
    case 21 :
        image.append(jjstrLiteralImages[21]);
        lengthOfMatch = jjstrLiteralImages[21].length();
        parens++;

        break;
    case 22 :
        image.append(jjstrLiteralImages[22]);
        lengthOfMatch = jjstrLiteralImages[22].length();
        parens--;

        break;
    case 112 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        matchedToken->image = image;

        break;
    case 113 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        matchedToken->image = image;

        break;
    case 114 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        matchedToken->image = image;

        break;
    case 115 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        matchedToken->image = image;

        break;
    case 116 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        matchedToken->image = image;

        break;
    case 117 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        matchedToken->image = image;

        break;
    case 118 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        matchedToken->image = image;

        break;
    case 119 :
        image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
        matchedToken->image = image;

        break;
    default :
        break;
    }
}

void PythonGrammar30TokenManager::jjCheckNAdd(int state) {
    if (jjrounds[state] != jjround)
    {
        jjstateSet[jjnewStateCnt++] = state;
        jjrounds[state] = jjround;
    }
}

void PythonGrammar30TokenManager::jjAddStates(int start, int end) {
    do {
        jjstateSet[jjnewStateCnt++] = jjnextStates[start];
    } while (start++ != end);
}

void PythonGrammar30TokenManager::jjCheckNAddTwoStates(int state1, int state2) {
    jjCheckNAdd(state1);
    jjCheckNAdd(state2);
}


void PythonGrammar30TokenManager::jjCheckNAddStates(int start, int end) {
    do {
        jjCheckNAdd(jjnextStates[start]);
    } while (start++ != end);
}

/** Reinitialise parser. */
void PythonGrammar30TokenManager::ReInit(CharStream *stream, int lexState, PythonGrammar30 *parserArg) {
    if (input_stream) delete input_stream;
    jjmatchedPos = jjnewStateCnt = 0;
    curLexState = lexState;
    input_stream = stream;
    ReInitRounds();
    debugStream = stdout; // init
    SwitchTo(lexState);
    parser = parserArg;
}

void PythonGrammar30TokenManager::ReInitRounds() {
    int i;
    jjround = 0x80000001;
    for (i = 82; i-- > 0;)
        jjrounds[i] = 0x80000000;
}

/** Switch to specified lex state. */
void PythonGrammar30TokenManager::SwitchTo(int lexState) {
    if (lexState >= 18 || lexState < 0)
        //assert(false);
        //throw 1;//new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
        throw QString("Error: Ignoring invalid lexical state : %1. State unchanged.").arg(lexState);
    else
        curLexState = lexState;
}

/** Constructor. */
PythonGrammar30TokenManager::PythonGrammar30TokenManager (CharStream *stream, int lexState, PythonGrammar30 *parserArg) {
    input_stream = NULL;
    ReInit(stream, lexState, parserArg);
}

// Destructor
PythonGrammar30TokenManager::~PythonGrammar30TokenManager () {
    //if (input_stream) delete input_stream;
}
